//
//  main.c
//  Math04
//
//  Created by Xavier on 2023/10/24.
//

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int matrix[4][4]={0};
int mm[4][4];

 /*
  * 获得0-1关系矩阵
    A={1，2，3，4}
  */
void getMatrix(int n,int matrix[][4]){

        int len = 4 * 4;
        int i,j;

        int *bin = (int *)(malloc( sizeof(int)* len ));
         for(i=0;i<4;i++)
             for(j=0;j<4;j++)
                matrix[i][j]=0;
    
        for(i=0;i<len;i++)
        {    bin[len-1-i]=n%2;
            n = n/2;
        }
        
        for (j = 0; j < len; j++)
        {
                matrix[j/4][j%4]= bin[j];
        }
        free(bin);
}

 /*
  * 关系矩阵的合成运算 M o M
  */
void relationPower(int m[][4],int mm[][4]){
     int i,j;

     for(i=0;i<4;i++)
         for(j=0;j<4;j++)
            mm[i][j]=0;

    for(i=0;i<4;i++){
        for(j=0;j<4;j++){
            mm[i][j] = m[i][0] * m[0][j]
                     + m[i][1] * m[1][j]
                     + m[i][2] * m[2][j]
                     + m[i][3] * m[3][j];
            if (mm[i][j] >= 1) mm[i][j] = 1;
        }
    }
}


 /*
  * 关系的自反性判断
  */
int isReflective(int m[][4]){
    int flag =1;     //当flag为1时表示关系是自反的
    int i;
    for(i=0;i<4;i++)
        if(m[i][i] !=1)
        {
            flag=0;
            break;
        }
    return flag;
}

 /*
  * 关系的对称性判断
  */
int isSymmetry(int m[][4]){
    //补充代码完成对称关系的判断函数
//    if (m[1][0] == m[0][1] && m[2][0] == m[0][2] && m[2][1] == m[1][2] &&
//        m[3][0] == m[0][3] && m[3][1] == m[1][3] && m[3][2] == m[2][3]) {
//        return 1;
//    }
//    return -1;
    
        for(int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (m[i][j] != m[j][i] ) {
                    return -1;
                }
            }
        }
        
        return 1;
}

int isNotSymmetry(int m[][4]){
    //补充代码完成对称关系的判断函数
//    if (m[1][0] == m[0][1] && m[2][0] == m[0][2] && m[2][1] == m[1][2] &&
//        m[3][0] == m[0][3] && m[3][1] == m[1][3] && m[3][2] == m[2][3]) {
//        return 1;
//    }
//    return -1;
    
        for(int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (i != j) {
                    if (m[i][j] == 1 && 1 == m[j][i]) {
                        return -1;
                    }
                }
                
            }
        }
        return 1;
}
    
/*
 * 关系的传递性判断
 * 用定义就是 R。R 属于 R
 */
int isTransmit(int m[4][4]) {
    //m为原矩阵 m2为合成后的矩阵
    int m2[4][4] = {0};
    for(int i=0;i<4;i++){
        for(int j=0;j<4;j++){
            m2[i][j]=0;
        }
    }
    relationPower(m, m2);
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            if (m2[i][j] == 1 && m[i][j] != 1) {
                return -1;
            }
        }
    }
    return 1;
}

 /*
  * 打印0-1关系矩阵
  */
void displayRelation(int m[][4])
{
     int i,j;
    printf("    ");
    for (int i = 0; i < 5; i++) {
        
        if (i == 0) {
            continue;
        }
        printf("%d ",i);
    }
    printf("\n");
     for(i=0;i<4;i++)
     {   printf("%d ", i+1);
         printf("[ ");
             for(j=0;j<4;j++)
                printf("%d ",m[i][j]);
             printf("] \n");


     }
     printf("\n");
}

 /*
  * 统计（自反的、对称的、传递的）关系数量
  */
void countRelations(int size){
        //int size =4;
        int relationSize = (int)pow(2, size*size); //2^16
        int i;
        int count=0;
        for (i = 0; i < relationSize; i++)
        {
                        
            getMatrix(i,matrix);
            
            //统计自反关系的数量
//             if( isReflective(matrix)==1){
//                 displayRelation(matrix);
//                count++;
//             }
             
             //统计对称关系的数量
//             if( isSymmetry(matrix)==1){
//                 displayRelation(matrix);
//                count++;
//             }
            
            //统计传递关系的数量
//            if( isTransmit(matrix) == 1) {
//                displayRelation(matrix);
//               count++;
//            }
            
            //统计等价关系的数量
//            if ( isReflective(matrix)==1 && isSymmetry(matrix)==1 && isTransmit(matrix) == 1) {
//                displayRelation(matrix);
//                count++;
//            }
            
            //统计偏序关系的数量
            if ( isReflective(matrix)==1 && isNotSymmetry(matrix)==1 && isTransmit(matrix) == 1) {
                displayRelation(matrix);
                count++;
            }
                
             
        }
        //printf("总共%d 自反关系总数\n",count);
        //printf("总共%d 对称关系总数\n",count);
        //printf("总共%d 传递关系总数\n",count);
        //printf("总共%d 等价关系总数\n",count);
        printf("总共%d 偏序关系总数\n",count);
    }
    
int main(int argc, const char * argv[]) {
    // A={1，2，3，4}  |A| = 4
    countRelations(4);
    return 0;
}
